In `@backend/app/alembic/versions/043_add_score_trace_url_to_evaluation_run.py`:
- Around line 19-32: The migration functions upgrade and downgrade lack return
type hints; update the function signatures for upgrade() and downgrade() to
declare return type -> None so they read as upgrade() -> None: and downgrade()
-> None: (keep existing bodies unchanged) to satisfy the type-hinting rule.

In `@backend/app/core/storage_utils.py`:
- Around line 151-152: The log statement in load_json_from_object_store has a
missing closing quote and brace in the f-string; update the logger.info call
(logger.info(...)) to properly close the string and include the url variable,
e.g., fix the f-string to something like f"[load_json_from_object_store] Loading
JSON from '{url}'" so the message is well-formed and includes the trailing quote
and bracket.

In `@backend/app/services/evaluations/evaluation.py`:
- Around line 233-267: The code in get_evaluation_with_scores treats S3 and DB
as mutually exclusive (uses `elif`), so if `eval_run.score_trace_url` exists but
`load_json_from_object_store` fails or returns None you never fall back to DB
traces (`has_cached_traces_db`); change the control flow so the DB check is a
separate conditional executed after the S3 attempt/exception (i.e., replace the
`elif has_cached_traces_db` with an independent `if has_cached_traces_db` and
ensure the S3-exception handler does not return or suppress the subsequent DB
check), using the existing symbols `eval_run`, `score_trace_url`,
`has_cached_traces_db`, `load_json_from_object_store`, and
`get_evaluation_with_scores` to locate and update the logic.

In `@backend/app/tests/core/test_storage_utils.py`:
- Around line 57-98: The test methods in TestLoadJsonFromObjectStore lack
parameter type hints; update each method signature (test_load_success,
test_load_returns_none_on_error, test_load_returns_none_on_invalid_json) to
include the implicit self parameter type (self: "TestLoadJsonFromObjectStore")
and an explicit return type -> None; ensure any local test helper parameters
would also be annotated (e.g., mock_storage: MagicMock) if present, and keep the
body unchanged so assertions against load_json_from_object_store and
mock_storage.stream continue to work.
- Around line 16-55: The test methods in class TestUploadJsonlToObjectStore lack
type annotations on the implicit self parameter; update the method signatures
for test_upload_success and test_upload_returns_none_on_error to annotate self
(e.g., self: TestUploadJsonlToObjectStore) while keeping the existing return
type hints, and run tests to ensure no behavioral changes; locate these methods
and the class name TestUploadJsonlToObjectStore and add the self parameter type
annotation accordingly.

In `@backend/app/tests/crud/evaluations/test_score_storage.py`:
- Around line 14-110: The fixture mock_eval_run should be a factory (callable)
and the test functions need parameter type hints; change the fixture name to
mock_eval_run_factory (or make mock_eval_run return a Callable[[], MagicMock])
that when called creates/returns a MagicMock(spec=EvaluationRun) with id=100,
then inside tests call mock_eval_run_factory() to get the eval_run; also add
type annotations to each test parameter (e.g., mock_engine: MagicMock,
mock_get_storage: MagicMock, mock_upload: MagicMock, mock_get_eval: MagicMock,
mock_update: MagicMock, mock_eval_run_factory: Callable[[], EvaluationRun] or
MagicMock) and return type -> None for
test_uploads_traces_to_s3_and_stores_summary_only,
test_fallback_to_db_when_s3_fails, and test_no_s3_upload_when_no_traces; keep
references to save_score and update_evaluation_run/get_evaluation_run_by_id
unchanged.

In `@backend/app/tests/services/evaluations/test_evaluation_service_s3.py`:
- Around line 42-120: The tests lack type hints: add annotations to the test
methods' parameters and fixtures referenced in this file—annotate mock
parameters (mock_get_storage, mock_load, mock_get_eval, mock_get_langfuse,
mock_fetch_langfuse, mock_save_score) as MagicMock, annotate fixture parameters
completed_eval_run_with_s3 and completed_eval_run_with_db_traces as
EvaluationRun, and annotate self as "TestGetEvaluationWithScoresS3" on the
methods test_loads_traces_from_s3, test_returns_db_traces_when_no_s3_url, and
test_resync_bypasses_cache_and_fetches_langfuse; also add return type
annotations for the fixtures (completed_eval_run_with_s3 -> EvaluationRun,
completed_eval_run_with_db_traces -> EvaluationRun) and import MagicMock and
EvaluationRun types where needed.
- Around line 14-37: Replace the two near-duplicate fixtures
completed_eval_run_with_s3 and completed_eval_run_with_db_traces with a single
factory fixture (e.g., eval_run_factory) that accepts parameters like id: int,
status: str, score: dict, score_trace_url: Optional[str], dataset_name:
Optional[str], run_name: Optional[str] and returns a
MagicMock(spec=EvaluationRun) populated accordingly; update tests to call
eval_run_factory(…) to create the two scenarios. Add explicit type hints to the
fixture and returned value (eval_run_factory: Callable[..., MagicMock] or ->
MagicMock) and to all test function parameters (e.g., mock_get_storage:
MagicMock, eval_run_factory: Callable[..., MagicMock]) so every fixture/test
signature is typed. Ensure existing symbols EvaluationRun,
completed_eval_run_with_s3 and completed_eval_run_with_db_traces are
removed/replaced and all tests updated to use the new eval_run_factory and typed
parameters.

In `@backend/app/alembic/versions/044_add_score_trace_url_to_evaluation_run.py`:
- Around line 1-7: The module docstring's Revision ID ("Revision ID: 043") is
out of sync with the migration metadata; update the docstring to "Revision ID:
044" so it matches the module-level revision variable named revision (and keep
the existing down_revision value unchanged); locate the top-of-file docstring
and replace the incorrect ID to ensure the header and the revision variable
(revision = "044") are consistent.

In `@backend/app/core/storage_utils.py`:
- Around line 158-170: The return type of load_json_from_object_store is too
narrow: json.loads can return dict, list, str, int, float, bool, or None; update
the function signature (load_json_from_object_store) to a broader typing such as
dict | list | None or typing.Any/typing.Union[...] as appropriate for callers,
and adjust any related type hints/imports if needed so the declared return type
matches json.loads' possible return types.
- Around line 114-120: Remove the trailing whitespace and wrap the long
assignment so it complies with Black/line-length rules: in the branch where
format == "jsonl" update the jsonl_content and content_type assignments
(referencing jsonl_content, content_type, format and results) to avoid a single
long line—e.g., build the "\n".join(...) expression across multiple lines or
assign the generator to an intermediate variable and then join, and ensure there
is no trailing space at the end of the line; do the same style-wise for the else
branch (json.dumps(results, ensure_ascii=False)) to keep lines under the limit.

In `@backend/app/crud/evaluations/core.py`:
- Around line 387-388: Fix the typo in the TODO comment: change "weather" to
"whether" in the comment line that starts with "# TODO: Evaluate weather this
behaviour..." located near the "# IF TRACES DATA IS STORED IN S3 URL..." block
in evaluations core (the TODO comment referencing storing data in db).

In `@backend/app/tests/crud/evaluations/test_score_storage.py`:
- Around line 94-110: Add an assertion that update_evaluation_run (mock_update)
was called with the expected payload when traces is empty: after calling
save_score(...) assert mock_update.assert_called_once() and that it was called
with eval_run_id=100, organization_id=1, project_id=1 and an update dict
containing the same score object and "score_trace_url": None (or equivalent key
used in the code); reference the test function test_no_s3_upload_when_no_traces
and the save_score call to locate where to insert these assertions.

In `@backend/app/crud/evaluations/core.py`:
- Around line 353-401: The resync can leave a stale S3 URL in the DB because
when traces are empty score_trace_url remains None and update_evaluation_run
won't clear the existing value; in save_score, detect the case of empty traces
on resync and explicitly clear the stored URL (e.g., set score_trace_url = "" or
add a separate clear flag) before calling update_evaluation_run so the DB entry
is overwritten/cleared; update the logic that builds db_score and the arguments
passed to update_evaluation_run (referencing save_score, score_trace_url,
upload_jsonl_to_object_store, and update_evaluation_run) to ensure an explicit
clear is persisted when traces are absent.

In `@backend/app/tests/services/evaluations/test_evaluation_service_s3.py`:
- Around line 77-78: The test is patching get_cloud_storage at the wrong import
path; change the second decorator to patch get_cloud_storage where the
evaluation service imports it (use
"app.services.evaluations.evaluation.get_cloud_storage" to match the module
under test) so that the mock is applied correctly to the EvaluationService code;
also verify the patched parameter order in the test function matches the
decorator order for get_evaluation_run_by_id and get_cloud_storage.
- Around line 109-114: The test is patching
app.core.storage_utils.load_json_from_object_store and
app.core.cloud.storage.get_cloud_storage directly, but you must patch the names
as they are imported/used in the module under test; change those two decorators
to patch "app.services.evaluations.evaluation.load_json_from_object_store" and
"app.services.evaluations.evaluation.get_cloud_storage" so the mocks replace the
references used by the functions under test (referencing
load_json_from_object_store and get_cloud_storage in the evaluation module).
- Around line 40-48: The test patches are targeting the original modules instead
of the names imported into evaluation.py, so update the `@patch` decorators to
patch the symbols as looked up by app.services.evaluations.evaluation: replace
patch("app.core.storage_utils.load_json_from_object_store") with
patch("app.services.evaluations.evaluation.load_json_from_object_store"),
patch("app.core.cloud.storage.get_cloud_storage") with
patch("app.services.evaluations.evaluation.get_cloud_storage"), and likewise
ensure get_evaluation_run_by_id is patched as
patch("app.services.evaluations.evaluation.get_evaluation_run_by_id") so mocks
for load_json_from_object_store, get_cloud_storage, and get_evaluation_run_by_id
intercept calls inside the load_traces logic in evaluation.py.